package com.example.demo1.paixusunanfa;

/**
 * @Author zx
 * @Date 2022/2/18 10:01
 * @Version 1.0
 */
public class MaoPao {
    /**
     * 里层循环只是比较相邻的两个数的大小并变换位置，所以需要在外层套一个循环来重复里层循环的步骤
     * 冒泡排序思路：
     *
     *     比较相邻的元素。如果第一个比第二个大，就交换他们两个。
     *     对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
     *     针对所有的元素重复以上的步骤，除了最后一个。
     *     持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
     */
    //[2,1,5,3,6,2,8]
    public int[] sort(int[] arrys){
        for (int i=0;i<arrys.length;i++){
            for (int j=0;j<arrys.length-1;j++){
                if (arrys[j]>arrys[j+1]){
                    int temp = arrys[j];
                    arrys[j] = arrys[j+1];
                    arrys[j+1] = temp;
                }
            }
        }
        return arrys;
    }

    /**
     * Java实现冒泡排序优化
     *
     *     冒泡有一个最大的问题就是这种算法不管不管你有序还是没序，闭着眼睛把你循环比较了再说。
     *
     *     比如我举个数组例子：[ 5，6，7，8，9 ]，一个有序的数组，根本不需要排序，它仍然是双层循环一个不少的把数据遍历干净，这其实就是做了没必要做的事情，属于浪费资源。
     *
     *     针对这个问题，我们可以设定一个临时遍历来标记该数组是否已经有序，如果有序了就不用遍历了。
     */
    public static void sort1(int arr[]){
        for( int i = 0;i < arr.length - 1 ; i++ ){
            boolean isSort = true;
            for( int j = 0;j < arr.length - 1 - i ; j++ ){
                int temp = 0;
                if(arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    isSort = false;
                }
            }
            if(isSort){
                break;
            }
        }
    }





    public static void main(String[] args) {
        MaoPao maoPao = new MaoPao();
        int[] arrys = {2,1,5,3,6,2,8};
        arrys = maoPao.sort(arrys);
        for (int arry : arrys) {
            System.out.println(arry);
        }
    }
}
